package com.hyfrogx.modules.app.controller.task;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hyfrogx.common.param.JSONResult;
import com.hyfrogx.common.utils.R;
import com.hyfrogx.modules.app.annotation.Login;
import com.hyfrogx.modules.app.entity.User;
import com.hyfrogx.modules.app.form.Task.TaskForm;
import com.hyfrogx.modules.app.form.Task.TaskInfoOV;
import com.hyfrogx.modules.app.service.UserService;
import com.hyfrogx.modules.app.utils.FrogxTaskCode;
import com.hyfrogx.modules.manage.controller.BaseController;
import com.hyfrogx.modules.manage.entity.coin.CoinDetailEntity;
import com.hyfrogx.modules.manage.entity.course.CourseManageEntity;
import com.hyfrogx.modules.manage.entity.task.TaskEntity;
import com.hyfrogx.modules.manage.entity.task.TaskRewardEntity;
import com.hyfrogx.modules.manage.entity.task.TaskUserInfoEntity;
import com.hyfrogx.modules.manage.service.course.CourseManageService;
import com.hyfrogx.modules.manage.service.task.TaskRewardService;
import com.hyfrogx.modules.manage.service.task.TaskService;
import com.hyfrogx.modules.manage.service.task.TaskUserInfoService;
import com.hyfrogx.modules.manage.util.ScoreCoinUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.*;
/**
 * @author 罗春杰-技术部
 */
@RestController
@RequestMapping(value = "api/task")
@Slf4j
@Api(value = "ApiTaskController",tags = {"客户端-任务管理页面"})
public class ApiTaskController extends BaseController {

    @Autowired
    private TaskService taskService;

    @Autowired
    private TaskRewardService rewardService;

    @Autowired
    private UserService userService;

    @Autowired
    private TaskUserInfoService userInfoService;

    @Autowired
    private CourseManageService manageService;

    /**
     * 考虑到新手/每日/高级任务,
     * 各自对于完成任务的判断都很复杂,
     * 所以拆分接口做
     *
     * @Description
     * 用户完成新手任务情况列表
     */
    @Login
    @RequestMapping(value = "getNoviceTask", method = RequestMethod.POST)
    @ApiOperation("用户完成新手任务情况列表")
    public R getNoviceTask(@RequestAttribute("userId") Integer uid) throws Exception {
        // 1.获取所有该类型,已上架新手任务列表
        List<TaskEntity> taskList = taskService.list(new QueryWrapper<TaskEntity>().eq("type", FrogxTaskCode.TaskType.NOVICE).eq("status",1));
        if(taskList.size() <= 0){
            return R.error("当前未配置新手任务");
        }
        // 查询用户信息(包含注册及个人资料);定义上线时间
        User user = userService.getUsersById(uid);
        Long pubulisTime = 1569399301243L;
        // 2.遍历任务,正常可完成的就从集合中移除掉,1-可领奖励 2-可移除 查不出该用户该任务完成情况,就是没做过这个任务.置为0
        for (Iterator<TaskEntity> it = taskList.iterator(); it.hasNext();) {
            TaskEntity task = it.next();
            Integer max = taskService.selectMaxCoinByCode(task.getCode());
            if(max == null){
                max = 0;
            }
            task.setMaxCoin(max);
            // 3.如果该任务是注册任务--(code
            // 1001)上线后，在本次上线前注册的用户均视为老用户注册用户和填写邀请码的任务。老用户不送，不显示；
            if (user.getCreated().getTime() < pubulisTime && task.getCode() == FrogxTaskCode.TaskCode.REGISTER) {
                it.remove();
                continue;
            }
            // 4.查看该用户--该编号新手任务完成情况 -- 新手任务只能完成一次,所以可以对象接,每日任务要加条件查询并且可能返回集合
            TaskUserInfoEntity info = userInfoService.getOne(new QueryWrapper<TaskUserInfoEntity>()
                    .eq("uid",uid).eq("task_code",task.getCode()));
            if (info == null) {
                // 5.
                // 没有记录的一定是待完成状态了。(因为注册一定会生成任务记录,让用户去领取,完善信息,填写邀请码了也同理,手动拉取列表记录,然后变更状态)
                task.setGoingStatus(0);
            } else {
                // 6.如果是已存在记录,有两种情况--第一种:已完成待领取;第二种：已领取奖励
                if (info.getStatus() == 2) {
                    it.remove();
                } else {
                    task.setGoingStatus(info.getStatus());
                }
            }
        }
        return R.ok().put("data",taskList);
    }

    /*
     * @Description 用户完成每日任务情况列表
     */
    @Login
    @RequestMapping(value = "getDailyTask", method = RequestMethod.POST)
    @ApiOperation("用户完成每日任务情况列表")
    public R getDailyTask(@RequestAttribute("userId") Long uid) {
        try {

            // 1.获取所有该类型,已上架新手任务列表
            List<TaskEntity> taskList = taskService.list(new QueryWrapper<TaskEntity>()
                    .eq("type", FrogxTaskCode.TaskType.DAILY).eq("status",1));
            if (taskList.size() <= 0) {
                return R.error("当前未配置每日任务");
            }
            // 获取当天的任务完成次数
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            String toDate = sdf.format(new Date());

            for (Iterator<TaskEntity> it = taskList.iterator(); it.hasNext();) {
                TaskEntity task = it.next();
                Integer max = taskService.selectMaxCoinByCode(task.getCode());
                if(max == null){
                    max = 0;
                }
                task.setMaxCoin(max);
                // 查询出当天完成次数
                Integer count = userInfoService.count(new QueryWrapper<TaskUserInfoEntity>()
                        .eq("task_code",task.getCode()).eq("date",toDate).eq("uid",uid));

                // 查询任务记录表中用户完成记录
                if (count == 0) {
                    // 没有记录的一定是待完成状态了。(因为注册一定会生成任务记录,让用户去领取,完善信息,填写邀请码了也同理,手动拉取列表记录,然后变更状态)
                    task.setGoingStatus(0);
                    // 记录完成次数
                    task.setCompletedNumber(0);
                } else {
                    // 记录完成次数
                    task.setCompletedNumber(count);
                    // 查询出次数和规定完成次数相同改变任务状态
                    if (task.getTotal() <= count) {
                        task.setGoingStatus(1);
                    } else {
                        task.setGoingStatus(0);
                    }
                }
            }
            return R.ok().put("data",taskList);
        } catch (Exception e) {
            return R.error(e.getMessage());
        }
    }

    /*
     * @Description 用户完成高阶任务情况列表
     */
    @Login
    @RequestMapping(value = "getSeniorTask", method = RequestMethod.POST)
    @ApiOperation("用户完成高阶任务情况列表")
    public R getSeniorTask(@RequestAttribute("userId") Long uid) throws Exception {
        // 1.获取所有该类型,已上架新手任务列表
        List<TaskEntity> taskList = taskService.list(new QueryWrapper<TaskEntity>()
                .eq("type",FrogxTaskCode.TaskType.SENIOR));
        if (taskList.size() <= 0) {
            return R.error("当前未配置高阶任务");
        }
        // 查询任务记录表中用户完成记录
        // HyTaskUserInfo info = taskUserInfoService.getTaskInfoNovice(uid,
        // hytask.getCode());
        R dailyTask = this.getDailyTask(uid);
        log.info("每日任务列表："+dailyTask.get("data"));
        String data = JSON.toJSONString(dailyTask.get("data"));
        JSONArray parseArray = JSONArray.parseArray(data);
        Boolean num = true;
        for (int i = 0; i < parseArray.size(); i++) {
            TaskEntity task = parseArray.getObject(i, TaskEntity.class);
            if (task.getGoingStatus() == 0) {
                num = false;
                break;
            }
        }
        for (Iterator<TaskEntity> it = taskList.iterator(); it.hasNext();) {
            TaskEntity task = it.next();
            task.setGoingStatus(0);
            // 完成所有的每日任务
            if (task.getCode() == FrogxTaskCode.TaskCode.FINISH_DAILY && num == true) {
                TaskForm taskForm = new TaskForm();
                taskForm.setCode(FrogxTaskCode.TaskCode.FINISH_DAILY);
                taskForm.setUid(uid);
                taskService.taskShare(taskForm);
                task.setGoingStatus(1);
            }
        }
        return R.ok().put("data",taskList);
    }

    /*
     * @Description 用户领取新手任务奖励
     */
    @Login
    @RequestMapping(value = "commitNoviceTask", method = RequestMethod.POST)
    @ApiOperation("用户领取新手任务奖励")
    public @ResponseBody JSONResult commitNoviceTask(@RequestAttribute("userId") Integer uid, Integer taskCode) throws Exception {
        // 检查该任务有没有完成并且有没有领取奖励
        TaskUserInfoEntity info = userInfoService.getOne(new QueryWrapper<TaskUserInfoEntity>()
                .eq("uid",uid).eq("task_code",taskCode));
        if (info != null) {
            if (info.getStatus() == 2) {
                return ajaxFail("您已领取奖励");
            } else {
                TaskEntity taskEntity = taskService.getOne(new QueryWrapper<TaskEntity>().eq("code", taskCode));
                // 1.查询用户信息
                User user = userService.getUsersById(uid);
                // 2.给用户处理积分余额
                userService.addScore(user.getUid(), info.getRewordScore());
                // 3.发送订单到积分中间系统
                CoinDetailEntity coin = new CoinDetailEntity();
                coin.setCoin(Long.valueOf(info.getRewordScore()));
                coin.setDesc("完成" + taskEntity.getName());
                coin.setMark(taskEntity.getName());
                coin.setNickname(user.getUsername());
                coin.setTerminal("sever");
                coin.setType("获得");
                // 3.获取该用户token
                String coinToken = ScoreCoinUtils.getToken(user.getPhone());
                // 4.发送包体至积分项目[userId + channelCode(积分系统通过token直接获取) +
                // CoinDetailEntity
                ScoreCoinUtils.sendPackage(coin, coinToken);
                // 5.修改任务完成状态
                info.setStatus(FrogxTaskCode.TaskStatus.RECEIVE);
                info.setCommitTime(new Date());
                userInfoService.updateById(info);
                return ajaxSuccess("领取成功");
            }
        } else {
            return ajaxFail("用户尚未完成任务");
        }

    }


    /**
     * 分享课程、快讯、资讯、直播、每日任务、学习课程、观看直播    任务
     * @param taskForm
     * @return
     */
    @Login
    @ApiOperation("分享课程、快讯、资讯、直播、每日任务、学习课程、观看直播-任务")
    @RequestMapping(value = "taskWatch", method = RequestMethod.POST)
    public R taskWatch(  @RequestBody TaskForm taskForm) {
        try {
            taskService.taskShare(taskForm);
        } catch (Exception e) {
            return R.error(e.getMessage());
        }
        return R.ok("任务完成");
    }

    /**
     * 阅读资讯任务 和 评论的任务接口同一个
     */
    @ApiOperation("阅读资讯任务")
    @RequestMapping(value = "taskRemark", method = RequestMethod.POST)
    public R taskShare(@RequestBody TaskForm taskForm) {
        try {
            taskService.taskRemark(taskForm.getUid(),taskForm.getCode(),taskForm.getSid());
        } catch (Exception e) {
            return R.error(e.getMessage());
        }
        return R.ok("任务完成");

    }

    /**
     * 会议任务接口
     */
    @ApiOperation("会议任务接口")
    @RequestMapping(value = "taskMeeting", method = RequestMethod.POST)
    public R taskMeeting( Long uid, Integer code, Integer meetingId) {
        try {
            taskService.taskMeeting(uid, code, meetingId);
        } catch (Exception e) {
            e.printStackTrace();
            return R.error(e.getMessage());
        }
        return R.ok("会议任务完成");

    }


    /**
     * 任务完成次数
     */
    @ApiOperation("任务完成次数")
    @RequestMapping(value = "taskNum", method = RequestMethod.POST)
    public R taskNum(@RequestBody TaskForm taskForm) {
        try {
            Integer count = 0;
            if (taskForm.getUid() != null) {
                // 获取当天的任务完成次数
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                String toDate = sdf.format(new Date());
                count = userInfoService.count(new QueryWrapper<TaskUserInfoEntity>()
                        .eq("task_code", taskForm.getCode()).eq("date", toDate)
                        .eq("uid", taskForm.getUid()));
            }
            TaskEntity taskByCode = taskService.getOne(new QueryWrapper<TaskEntity>()
                    .eq("code", taskForm.getCode()).eq("status", 1));
            taskByCode.setCompletedNumber(count);
            return R.ok().put("data", taskByCode);
        } catch (Exception e) {
            e.printStackTrace();
            return R.error(e.getMessage());
        }
    }


    /**
     * 获取最大积分
     *
     */
    @RequestMapping(value = "getMaxCoin", method = RequestMethod.POST)
    public R getMaxCoin(Integer cid, Integer code) {
        try {
            TaskEntity task = taskService.getOne(new QueryWrapper<TaskEntity>().eq("code",code).eq("status",1));
            if (task != null) {
                List<TaskRewardEntity> hyTaskRewardByCode = rewardService.findHyTaskRewardByCode(task.getCode());
                Collections.sort(hyTaskRewardByCode, new Comparator<TaskRewardEntity>() {
                    @Override
                    public int compare(TaskRewardEntity o1, TaskRewardEntity o2) {
                        // 升序
                        return o1.getScale().compareTo(o2.getScale());
                    }
                });
                Integer scale = hyTaskRewardByCode.get(hyTaskRewardByCode.size() - 1).getScale();

                CourseManageEntity manage = manageService.getById(cid);

                Integer max = 0;
                if(manage.getTruePrice()>task.getMinBaseNum()){
                    max = (int) (Math.round(manage.getTruePrice() * (scale * 0.01)));
                }
                return R.ok().put("data",max);
            } else {
                return R.error("任务没有上架");
            }
        } catch (Exception e) {
            return R.error(e.getMessage());
        }
    }
}
